package cc.kzc.adminauth.auth.tool;

import java.nio.charset.StandardCharsets;
import java.security.GeneralSecurityException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.ECGenParameterSpec;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.UUID;

import javax.crypto.SecretKey;

import io.jsonwebtoken.security.Keys;

public class JwtKeyGenerator {

	public static SecretKey createHS256Key() {
		/**
		 * 私钥
		 * 
		 * <pre>
		 * 生成签名的时候使用的秘钥secret，一般可以从本地配置文件中读取，切记这个秘钥不能外露，只在服务端使用，在任何场景都不应该流露出去。
		 * 一旦客户端得知这个secret, 那就意味着客户端是可以自我签发jwt了。
		 * 应该大于等于 256位(长度32及以上的字符串)，并且是随机的字符串
		 * </pre>
		 */
		String secret_key_code = UUID.randomUUID().toString();
		/**
		 * 秘钥实例
		 */
		SecretKey secret_key = Keys.hmacShaKeyFor(secret_key_code.getBytes(StandardCharsets.UTF_8));
		return secret_key;
	}

	public static final String KEY_ALGORITHM_RSA = "RSA";
	public static final int RS256_KEY_SIZE = 2048; // 推荐至少 2048 位

	public static KeyPair createRS256KeyPair() throws GeneralSecurityException {
		KeyPairGenerator keyGen = KeyPairGenerator.getInstance(KEY_ALGORITHM_RSA);
		keyGen.initialize(RS256_KEY_SIZE);
		// 生成密钥对,保存 pair.getPublic() 和 pair.getPrivate() 到安全的地方
		KeyPair pair = keyGen.generateKeyPair();
		return pair;
	}

	public static final String KEY_ALGORITHM_EC = "EC";
	public static final String ES256_CURVE_NAME = "secp256r1"; // 对应于 NIST P-256 曲线

	public static KeyPair createES256KeyPair() throws GeneralSecurityException {
		KeyPairGenerator keyGen = KeyPairGenerator.getInstance(KEY_ALGORITHM_EC);
		ECGenParameterSpec ecSpec = new ECGenParameterSpec(ES256_CURVE_NAME);
		keyGen.initialize(ecSpec);

		// 生成密钥对
		KeyPair keyPair = keyGen.generateKeyPair();
		return keyPair;
	}

	public static String toKeyBase64(Key key) {
		return new String(Base64.getEncoder().encodeToString(key.getEncoded()));
	}

	public static PrivateKey parsePrivateKeyFromBase64(String base64Str, String Algorithm) {

		if (null == base64Str || 0 == base64Str.length()) {
			return null;
		}

		if (KEY_ALGORITHM_RSA.equals(Algorithm) || KEY_ALGORITHM_EC.equals(Algorithm)) {

			byte[] pkeyByte = Base64.getDecoder().decode(base64Str.getBytes(StandardCharsets.UTF_8));
			// 使用 PKCS#8 编码格式创建私钥规范
			PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(pkeyByte);
			try {
				// 创建 KeyFactory 实例，指定算法（例如 "RSA" 或 "EC"）
				KeyFactory keyFactory = KeyFactory.getInstance(Algorithm);

				// 生成并返回 PrivateKey 对象
				return keyFactory.generatePrivate(privateKeySpec);
			} catch (GeneralSecurityException e) {
				return null;
			}
		}
		return null;
	}

	public static PublicKey parsePublicKeyFromBase64(String base64Str, String Algorithm) {
		if (null == base64Str || 0 == base64Str.length()) {
			return null;
		}

		if (KEY_ALGORITHM_RSA.equals(Algorithm) || KEY_ALGORITHM_EC.equals(Algorithm)) {

			byte[] pkeyByte = Base64.getDecoder().decode(base64Str.getBytes(StandardCharsets.UTF_8));
			// 使用 X.509 编码格式创建公钥规范
			X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(pkeyByte);
			try {
				// 创建 KeyFactory 实例，指定算法（例如 "RSA" 或 "EC"）
				KeyFactory keyFactory = KeyFactory.getInstance(Algorithm);

				// 生成并返回 PublicKey 对象
				return keyFactory.generatePublic(publicKeySpec);
			} catch (GeneralSecurityException e) {
				return null;
			}
		}
		return null;
	}

}
